const storage = require('../../utils/storage.js');
const api = require('../../utils/api.js');
const wxpay = require('../../utils/wxpay.js');

Page({
  data: {
    // 用户积分信息
    userPoints: 0,
    currentLevel: 0,
    levelProgress: 0,
    progressText: '',
    
    // 积分套餐
    packages: [],
    selectedIndex: -1,
    isLoadingPackages: false,
    
    // 积分变更历史
    historyRecords: [],
    isLoadingHistory: false,
  },

  onLoad() {
    console.log('📱 =============== 积分充值页面加载 ===============');
    this.loadUserInfo();
    this.loadPackages();
    this.loadHistory();
  },

  onShow() {
    // 🔔 自动初始化通知组件
    const app = getApp();
    app.autoInitNotification();
    
    // 每次显示时刷新用户信息（支付返回后可能积分有变化）
    this.loadUserInfo();
  },

  /**
   * 🔥 加载用户信息（从服务器获取最新数据）
   */
  async loadUserInfo() {
    try {
      const userData = storage.getUserInfo();
      if (!userData || !userData.userPhone) {
        console.warn('⚠️ 用户信息不存在或缺少手机号');
        return;
      }

      console.log('🔄 开始从服务器获取最新用户信息...');
      console.log('📱 手机号:', userData.userPhone);

      // 🔥 从服务器获取最新的用户信息
      const response = await api.checkPhone(userData.userPhone);
      
      if (response.exists && response.data) {
        const latestUserData = response.data;
        const points = latestUserData.userPoints || 0;
        
        console.log('✅ 获取到最新积分:', points);
        console.log('📊 完整用户数据:', latestUserData);
        
        // 🔥 更新本地存储（保存最新的用户信息）
        storage.saveUserInfo(latestUserData);
        
        // 计算等级信息（参考Flutter项目）
        const levelInfo = this.calculateLevelInfo(points);
        
        // 更新页面显示
        this.setData({
          userPoints: points,
          currentLevel: levelInfo.currentLevel,
          levelProgress: levelInfo.progress * 100,
          progressText: levelInfo.isMaxLevel ? '已达到最高等级' : `升级所需积分 ${levelInfo.neededPoints}`
        });
        
        console.log('✅ 用户信息已更新到最新');
      } else {
        console.error('❌ 获取用户信息失败:', response);
      }
    } catch (error) {
      console.error('💥 加载用户信息异常:', error);
      
      // 🔥 如果服务器请求失败，降级使用本地存储的数据
      const userData = storage.getUserInfo();
      if (userData) {
        const points = userData.userPoints || 0;
        console.log('⚠️ 使用本地缓存的积分:', points);
        
        const levelInfo = this.calculateLevelInfo(points);
        
        this.setData({
          userPoints: points,
          currentLevel: levelInfo.currentLevel,
          levelProgress: levelInfo.progress * 100,
          progressText: levelInfo.isMaxLevel ? '已达到最高等级' : `升级所需积分 ${levelInfo.neededPoints}`
        });
      }
    }
  },

  /**
   * 计算等级信息（参考Flutter项目）
   */
  calculateLevelInfo(points) {
    const levelThresholds = [0, 100, 500, 1500, 3000, 6000]; // Lv0-Lv5
    
    let currentLevel = 0;
    for (let i = levelThresholds.length - 1; i >= 0; i--) {
      if (points >= levelThresholds[i]) {
        currentLevel = i;
        break;
      }
    }
    
    const isMaxLevel = currentLevel >= levelThresholds.length - 1;
    const nextLevelPoints = isMaxLevel ? levelThresholds[levelThresholds.length - 1] : levelThresholds[currentLevel + 1];
    const currentLevelPoints = levelThresholds[currentLevel];
    const neededPoints = nextLevelPoints - points;
    const progress = isMaxLevel ? 1.0 : (points - currentLevelPoints) / (nextLevelPoints - currentLevelPoints);
    
    return {
      currentLevel,
      nextLevelPoints,
      neededPoints: neededPoints > 0 ? neededPoints : 0,
      progress: Math.max(0, Math.min(1, progress)),
      isMaxLevel
    };
  },

  /**
   * 加载积分套餐
   */
  async loadPackages() {
    if (this.data.isLoadingPackages) return;
    
    try {
      this.setData({ isLoadingPackages: true });
      console.log('🔄 开始加载积分套餐列表');

      const response = await api.getPointsPackages();
      
      console.log('📦 积分套餐响应:', response);
      
      if (response.status === 'success' && response.data) {
        // 按sort_order排序
        const packages = response.data.sort((a, b) => a.sort_order - b.sort_order);
        
        this.setData({ packages });
        console.log(`✅ 积分套餐加载成功: ${packages.length}个套餐`);
      } else {
        console.error('❌ 积分套餐加载失败:', response.message);
        wx.showToast({
          title: '加载套餐失败',
          icon: 'none'
        });
      }
    } catch (e) {
      console.error('💥 加载积分套餐异常:', e);
      wx.showToast({
        title: '加载套餐异常',
        icon: 'none'
      });
    } finally {
      this.setData({ isLoadingPackages: false });
    }
  },

  /**
   * 加载积分变更历史
   */
  async loadHistory() {
    const userData = storage.getUserInfo();
    if (!userData) {
      console.warn('⚠️ 用户未登录，无法加载积分历史');
      return;
    }

    if (this.data.isLoadingHistory) return;
    
    try {
      this.setData({ isLoadingHistory: true });
      console.log('🔄 开始加载积分变更历史');

      const response = await api.getPointsHistory(userData.userid, 1);
      
      console.log('📜 积分历史响应:', response);
      
      if (response.status === 'success' && response.data) {
        // 处理历史记录，添加显示用的字段和字段名映射
        const records = response.data.records || [];
        const historyRecords = records.map(record => ({
          id: record.id,
          userid: record.userid,
          pointsChange: record.points_change,  // 字段名转换
          pointsBefore: record.points_before,
          pointsAfter: record.points_after,
          changeType: record.change_type,
          changeReason: record.change_reason,  // 字段名转换
          relatedId: record.related_id,
          operator: record.operator,
          remark: record.remark,
          status: record.status,
          createdAt: record.created_at,  // 字段名转换
          changeTypeText: this.getChangeTypeText(record.change_type),
        }));
        
        this.setData({ historyRecords });
        console.log(`✅ 积分历史加载成功: ${historyRecords.length}条记录`);
      } else {
        console.error('❌ 积分历史加载失败:', response.message || '未知错误');
      }
    } catch (e) {
      console.error('💥 加载积分历史异常:', e);
    } finally {
      this.setData({ isLoadingHistory: false });
    }
  },

  /**
   * 获取变动类型文本
   */
  getChangeTypeText(changeType) {
    const typeMap = {
      1: '签到',
      2: '购物',
      3: '活动奖励',
      4: '积分兑换',
      5: '管理员调整',
      6: '系统消耗'
    };
    return typeMap[changeType] || '其他';
  },

  /**
   * 选择积分套餐
   */
  selectPackage(e) {
    const index = e.currentTarget.dataset.index;
    console.log('✅ 选择积分套餐:', index);
    
    this.setData({
      selectedIndex: index
    });
  },

  /**
   * 购买积分套餐 - 微信支付
   */
  async purchasePackage() {
    if (this.data.selectedIndex < 0) {
      wx.showToast({
        title: '请选择积分套餐',
        icon: 'none'
      });
      return;
    }

    const selectedPackage = this.data.packages[this.data.selectedIndex];
    const userData = storage.getUserInfo();
    
    if (!userData) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    console.log('💰 ========== 开始购买积分套餐 ==========');
    console.log('📦 选中套餐:', selectedPackage);
    console.log('👤 当前用户:', userData.userid);

    try {
      // 调用微信支付流程
      const result = await wxpay.doPay({
        user_id: userData.userid,
        package_id: selectedPackage.package_id,
        package_name: selectedPackage.package_name,
        price: selectedPackage.price,
        points: selectedPackage.points_amount
      });

      if (result.success) {
        // 支付成功
        console.log('✅ 支付成功，订单号:', result.out_trade_no);
        
        // 根据是否成功查询到订单信息，显示不同提示
        if (result.orderInfo && result.orderInfo.tradeState === 'SUCCESS') {
          // 订单已确认成功，立即刷新
          wx.showToast({
            title: '支付成功，积分已到账',
            icon: 'success',
            duration: 2000
          });
          
          // 🔥 立即刷新用户信息和历史记录
          this.loadUserInfo();
          this.loadHistory();
        } else {
          // 查询失败或订单还在处理中
          wx.showModal({
            title: '支付成功',
            content: '您的支付已完成，积分将在几分钟内到账，正在为您刷新最新数据...',
            showCancel: false,
            confirmText: '知道了'
          });
          
          // 🔥 延迟3秒刷新（给服务器处理时间）
          setTimeout(() => {
            console.log('🔄 开始刷新最新积分数据...');
            this.loadUserInfo();
            this.loadHistory();
          }, 3000);
        }

        // 重置选择
        this.setData({ selectedIndex: -1 });

      } else {
        // 支付失败
        console.error('❌ 支付失败:', result.message);
        
        // 根据错误类型显示不同提示
        if (result.message && result.message.includes('取消')) {
          wx.showToast({
            title: '已取消支付',
            icon: 'none',
            duration: 2000
          });
        } else {
          wx.showModal({
            title: '支付失败',
            content: result.message || '支付过程中发生错误，请重试',
            showCancel: false,
            confirmText: '知道了'
          });
        }

        // 重置选择
        this.setData({ selectedIndex: -1 });
      }

    } catch (error) {
      console.error('💥 支付异常:', error);
      
      wx.showModal({
        title: '支付异常',
        content: error.message || '支付过程中发生异常，请稍后重试',
        showCancel: false,
        confirmText: '知道了'
      });

      // 重置选择
      this.setData({ selectedIndex: -1 });
    }

    console.log('🏁 ========== 购买流程结束 ==========');
  }
});

